package com.gzy.cs5.Repository;

import com.gzy.cs5.exception.BusinessException;
import com.gzy.cs5.exception.ErrorCode;
import com.gzy.cs5.lang.OrderStatus;
import com.gzy.cs5.model.Item;
import com.gzy.cs5.model.Order;
import com.gzy.cs5.service.SimpleOrderService;

import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import static com.gzy.cs5.lang.OrderStatus.*;

public class MemoryOrderRepository implements OrderRepository {
    private Map<String, Order> orders = new HashMap<>();
    private Map<String, Item> items = new HashMap<>();

    @Override
    public Order findById(String orderId) throws BusinessException {
        // 根据订单ID查找订单
        if (orders == null){
            throw new  BusinessException(ErrorCode.MOB);
        }
        return orders.get(orderId);

    }

    @Override
    public List<Order> findAll() {
        // 获取所有订单
        return new ArrayList<>(orders.values());
    }

    @Override
    public void save(Order order) {
        // 保存订单
        orders.put(order.getOrderId(), order);
    }

    @Override
    public void updateStatus(String orderId, OrderStatus status) throws BusinessException {
        // 根据订单ID更新订单状态
        Order order = orders.get(orderId);
        if (order == null) {
            throw new BusinessException(ErrorCode.ORDER_NOT_FOUND);
        }
        order.setStatus(status);
    }

    @Override
    public void updateItem(Item item) {
        // 这里不需要实现，因为库存更新已经在 InventoryManager 中处理
    }
    @Override
    public Item findItemById(String itemId) {
        // 根据商品ID查找商品
        return items.get(itemId);
    }

    @Override
    public void saveItem(Item item) {
        // 保存商品
        items.put(item.getItemId(), item); // 修改: item.getId() -> item.getItemId()
        generateOperationLog(item, "Item saved successfully");
    }

    @Override
    public void updateOrder(Order newOrder) throws BusinessException {
        // 更新订单信息
        String orderId = newOrder.getOrderId();
        List<Item> newItems = newOrder.getItems();
        Order existingOrder = orders.get(orderId);
        if (existingOrder == null) {
            throw new BusinessException(ErrorCode.ORDER_NOT_FOUND);
        }

        if (existingOrder.getStatus() == OrderStatus.PAID || existingOrder.getStatus() == OrderStatus.COMPLETED) {
            throw new BusinessException(ErrorCode.MODIFY_FORBIDDEN);
        }

        // 获取修改类型
        boolean isFullReplacement = isFullOrderReplacement(existingOrder, newItems);
        boolean isPartialModification = isPartialOrderModification(existingOrder, newItems);

        if (isFullReplacement) {
            // 整单替换逻辑
            updateOrderItems(existingOrder, newItems);
        } else if (isPartialModification) {
            // 部分修改逻辑
            validateItems(newItems);
            updateOrderItems(existingOrder, newItems);
        } else {
            throw new BusinessException(ErrorCode.INVALID_MODIFICATION_TYPE);
        }

        // 生成修改差异单
        generateModificationDifference(existingOrder, newItems);

        // 模拟商家审批
        boolean isApprovalPassed = approveModification(newItems);

        if (!isApprovalPassed) {
            throw new BusinessException(ErrorCode.MODIFICATION_REJECTED);
        }

        // 修改订单状态
        existingOrder.setStatus(OrderStatus.PROCESSING); // 假设修改订单状态为处理中

        // 生成操作日志
        generateOperationLog(existingOrder, "Order updated successfully");

        // 执行修改
        orders.put(orderId, existingOrder);
    }

    // 检查是否为整单替换
    private boolean isFullOrderReplacement(Order existingOrder, List<Item> newItems) {
        // 整单替换逻辑：如果新订单的商品列表与现有订单的商品列表完全相同，则视为整单替换
        return existingOrder.getItems().size() == newItems.size() &&
               existingOrder.getItems().containsAll(newItems);
    }

    // 检查是否为部分修改
    private boolean isPartialOrderModification(Order existingOrder, List<Item> newItems) {
        // 部分修改逻辑：如果新订单的商品列表与现有订单的商品列表不完全相同，则视为部分修改
        return !isFullOrderReplacement(existingOrder, newItems);
    }

    // 验证商品有效性
    private void validateItems(List<Item> items) throws BusinessException {
        // 验证商品列表中的每个商品是否有效
        for (Item item : items) {
            if (!isItemValid(item)) {
                throw new BusinessException(ErrorCode.ITEM_INVALID);
            }
        }
    }

    // 检查商品是否有效
    private boolean isItemValid(Item item) {
        // 这里可以添加具体的商品有效性检查逻辑
        return item.getStock() > 0; // 示例：检查商品库存是否大于0
    }

    // 更新订单商品
    private void updateOrderItems(Order existingOrder, List<Item> newItems) {
        // 更新订单商品列表
        existingOrder.setItems(newItems);
        // 更新订单总价
        existingOrder.setTotalPrice(calculateTotalPrice(newItems));
    }

    // 计算订单总价
    private double calculateTotalPrice(List<Item> items) {
        // 计算商品列表的总价
        double totalPrice = 0.0;
        for (Item item : items) {
            totalPrice += item.getPrice();
        }
        return totalPrice;
    }

    // 生成修改差异单
    private void generateModificationDifference(Order existingOrder, List<Item> newItems) {
        // 生成修改差异单的逻辑
        System.out.println("Generating modification difference for order ID: " + existingOrder.getOrderId());
        // 这里可以添加具体的修改差异单生成逻辑
    }

    // 模拟商家审批逻辑
    private boolean approveModification(List<Item> newItems) {
        // 这里可以添加具体的审批逻辑
        return true; // 假设审批总是通过
    }

    // 添加 generateOperationLog 方法
    private void generateOperationLog(Object entity, String message) {
        // 这里可以添加具体的日志生成逻辑
        System.out.println(LocalDateTime.now() + " - " + message);
    }
}